home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / common / AsyncSocket.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  7.3 KB  |  215 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import socket
  5. from socket import _socket as socket
  6. import threading
  7. import AsyncoreThread
  8. import util
  9. import traceback
  10. import sys
  11. import logging
  12. log = logging.getLogger('AsyncSocket')
  13. from asynchat import async_chat as _async_chat
  14. from asyncore import compact_traceback
  15. import asyncore
  16. _ok_errors = set((asyncore.EINPROGRESS, asyncore.EALREADY, asyncore.EWOULDBLOCK))
  17.  
  18. class async_chat(_async_chat):
  19.     
  20.     def connect(self, address):
  21.         self.connected = False
  22.         err = self.socket.connect_ex(address)
  23.         if err in _ok_errors:
  24.             return None
  25.         
  26.         if err in (0, asyncore.EISCONN):
  27.             self.addr = address
  28.             self.connected = True
  29.             self.handle_connect()
  30.         else:
  31.             raise socket.error, (err, asyncore.errorcode.get(err, 'unknown'))
  32.  
  33.  
  34.  
  35. class AsyncSocket(object, async_chat):
  36.     
  37.     def __init__(self, conn = None):
  38.         object.__init__(self)
  39.         self._lock = threading.RLock()
  40.         self._AsyncSocket__refcount = 0
  41.         self._proxy_setup = False
  42.         self._AsyncSocket__proxysocket = None
  43.         self._handlers = []
  44.         self.data = ''
  45.         if conn is False:
  46.             async_chat.__init__(self)
  47.             self._AsyncSocket__refcount += 1
  48.             AsyncoreThread.start()
  49.         elif conn is None:
  50.             async_chat.__init__(self)
  51.             self.make_socket()
  52.         else:
  53.             async_chat.__init__(self, conn)
  54.             self._AsyncSocket__refcount += 1
  55.             AsyncoreThread.start()
  56.  
  57.     
  58.     def make_socket(self, proxy = True):
  59.         if getattr(self, '_fileno', None) is not None:
  60.             self.del_channel()
  61.         
  62.         if proxy:
  63.             proxy = util.GetProxyInfo()
  64.         
  65.         self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
  66.         self._AsyncSocket__refcount += 1
  67.         AsyncoreThread.start()
  68.  
  69.     make_socket = util.lock(make_socket)
  70.     
  71.     def bind(self, addr):
  72.         retval = self.socket.bind(addr)
  73.         self.addr = self.socket.getsockname()
  74.         return retval
  75.  
  76.     
  77.     def log_info(self, message, type = 'info'):
  78.         if __debug__ or type != 'info':
  79.             etype = sys.exc_info()[0]
  80.             if etype is not None:
  81.                 traceback.print_exc()
  82.             
  83.         
  84.  
  85.     
  86.     def connect(self, address, use_proxy = True, callback = None):
  87.         if use_proxy:
  88.             proxyinfo = self.GetProxyInfo()
  89.         else:
  90.             proxyinfo = { }
  91.         log.info('asyncsocket.connect%r', address)
  92.         if isinstance(self, ProxySocket):
  93.             log.info('\t\twas already a proxy socket')
  94.             old_error = (None, callback.error)
  95.             
  96.             callback.error = lambda : (self.handle_close(), old_error())
  97.             async_chat.connect(self, address)
  98.         elif not (self._proxy_setup) and proxyinfo:
  99.             log.info('\t\tneed to setup proxies')
  100.             sck = self.socket
  101.             self.del_channel()
  102.             psck = ProxySocket(proxyinfo, sck, self.set_socket, callback)
  103.             self._AsyncSocket__proxysocket = psck
  104.             psck.connect(address)
  105.         elif self._proxy_setup:
  106.             log.info('\t\tproxy was already setup, calling handle_connect')
  107.             self.connected = True
  108.             self.handle_connect()
  109.         elif not proxyinfo:
  110.             log.info('\t\tno proxy neecessary')
  111.             self._proxy_setup = True
  112.             (None, AsyncoreThread.call_later)((lambda : async_chat.connect(self, address)), callback = callback)
  113.         else:
  114.             log.info('\t\terrr you didnt finish')
  115.  
  116.     connect = util.callsback(connect)
  117.     
  118.     def set_socket(self, sock, map = None):
  119.         async_chat.set_socket(self, sock, map)
  120.         return self
  121.  
  122.     
  123.     def GetProxyInfo(self):
  124.         return util.GetProxyInfo()
  125.  
  126.     
  127.     def close(self):
  128.         
  129.         def _doit():
  130.             log.info('closing socket %r', self)
  131.             psck = self._AsyncSocket__proxysocket
  132.             if psck is not None:
  133.                 log.info('Closing proxy socket: %r', psck)
  134.                 psck.close()
  135.             
  136.             self._AsyncSocket__proxysocket = None
  137.             async_chat.close(self)
  138.  
  139.         AsyncoreThread.call_later(_doit)
  140.  
  141.     
  142.     def close_when_done(self):
  143.         (AsyncoreThread.call_later,)((lambda : async_chat.close_when_done(self)))
  144.  
  145.     
  146.     def collect_incoming_data(self, data):
  147.         self.data += data
  148.  
  149.     
  150.     def push_handler(self, h):
  151.         self._handlers.append(h)
  152.  
  153.     
  154.     def pop_handler(self):
  155.         self._handlers.pop()
  156.  
  157.     
  158.     def found_terminator(self):
  159.         data = self.data
  160.         self.data = ''
  161.         return self.handle_data(data)
  162.  
  163.     
  164.     def handle_data(self, data):
  165.         if self._handlers:
  166.             return self._handlers[-1](data)
  167.         else:
  168.             return data
  169.  
  170.     
  171.     def handle_close(self):
  172.         while self._handlers:
  173.             self.pop_handler()
  174.  
  175.     
  176.     def handle_error(self, e = None):
  177.         if getattr(e, 'verbose', True):
  178.             import traceback
  179.             traceback.print_exc()
  180.         
  181.         log.error('Exception for %r: %r', self, e)
  182.         if e is None:
  183.             self.close()
  184.             return None
  185.         
  186.         
  187.         try:
  188.             raise e
  189.         except socket.error:
  190.             log.critical('Closing socket %r due to socket error', self)
  191.             self.close()
  192.         except Exception:
  193.             log.error('Unexpected exception in AsyncSocket.handle_error: %r', e)
  194.  
  195.  
  196.     
  197.     def handle_expt(self):
  198.         log.critical('%r: handle_expt (OOB data)...closing', self)
  199.         self.close()
  200.  
  201.     
  202.     def handle_error(self, e = None):
  203.         (nil, t, v, tbinfo) = compact_traceback()
  204.         
  205.         try:
  206.             self_repr = repr(self)
  207.         except:
  208.             self_repr = '<__repr__(self) failed for object at %0x>' % id(self)
  209.  
  210.         self.log_info('uncaptured python exception, closing channel %s (%s:%s %s)' % (self_repr, t, v, tbinfo), 'error')
  211.         self.close()
  212.  
  213.  
  214. from proxysockets import ProxySocket
  215.